A multicore processor is a single computing component with two or more independent processing units, which are also known as “cores.” A multicore computing system is usually used to run multiple threads in parallel with other resources, e.g., memory blocks, shared among different threads running on different cores. Of particular importance, multicore computing systems are advantageous in realizing embedded systems for a number of industrial applications. For example, a multicore computing system is usable in building a high-performance access gateway for a mobile communication system. Advantageously, the high-performance access gateway can be implemented by dedicating certain cores to process a majority of data packets outside an operating system (OS) environment (i.e. bypassing the OS) so as to achieve a high system throughput and a low latency, whereas remaining packets that require complex processing are forwarded to an OS networking stack and processed by other cores for performing necessary signaling and control functions. As such, it is advantageous that one thread is executed under a runtime environment specific to this thread and another thread runs on another optimized runtime environment. A runtime environment is characterized by, for example, the OS on which a thread is executed, the memory address space mapping, the input-output (TO) resources that can be used by the thread, whether or not the thread is tied to one particular core for execution, etc.
Owing to the presence of multiple runtime environments, a thread is classifiable into a suspendable thread or a non-suspendable thread. The suspendable thread is schedulable by an OS dispatcher whereas the non-suspendable thread is not and its execution cannot be suspended. A lock is usually used in the computing system to synchronize access to one or more shared resources by different threads. It is desirable to have a technique to operate the lock in the presence of suspendable and non-suspendable threads for a multicore computing system. However, most of existing techniques, such as the ones disclosed in US2007101333 and WO2013078962, are mainly engineered for suspendable threads without considering the presence of non-suspendable threads occurred in multiple runtime environments.
There is a need in the art for a technique to operate the lock in the presence of suspendable and non-suspendable threads arisen from multiple runtime environments.